package com.leetcode.根据数据结构分类.数组;

import java.util.ArrayList;
import java.util.List;

/**
 * @author: xiaomi
 * @date: 2021/1/22
 * @description: 989. 数组形式的整数加法
 * https://leetcode-cn.com/problems/add-to-array-form-of-integer/
 */
public class A_989_数组形式的整数加法 {


    public static void main(String[] args) {
        int[] array = new int[]{1, 2, 0, 0};
        int K = 34;
        A_989_数组形式的整数加法 action = new A_989_数组形式的整数加法();
        List<Integer> res = action.addToArrayForm(array, K);
        System.out.println("res = " + res);

    }

    /**
     * 1.将 A 通过 10进制的方式转为 X;
     * 2.计算 X+K
     * 3.通过 charAt 将字符串转为 A
     * --
     * 但是似乎太麻烦了
     * --
     * 不过会有 LONG 溢出的问题，所以只能先将 K 转为 A2 了
     *
     * @param A
     * @param K
     * @return
     */
    public List<Integer> addToArrayFormFail(int[] A, int K) {
        int len = A.length;
        long value = 0;
        for (int i = 0; i < len; i++) {
            value = value * 10 + A[i];
        }
        String newValue = (value + K) + "";
        int nlen = newValue.length();
        List<Integer> res = new ArrayList<>(nlen);
        for (int i = 0; i < nlen; i++) {
            res.add(Integer.parseInt(newValue.charAt(i) + ""));
        }
        return res;
    }


    /**
     * 这个本质也是【逐位相加】，但是太拘泥于形式了，没有必要把 K 转为 A2
     * @param A
     * @param K
     * @return
     */
    public List<Integer> addToArrayForm(int[] A, int K) {
        int[] A2 = getA(K);
        int minLen = Math.min(A.length, A2.length);
        int maxLen = Math.max(A.length, A2.length);
        //是否需要进位的标志
        boolean flag = false;
        List<Integer> res = new ArrayList<>(maxLen + 1);
        for (int i = 1; i <= maxLen; i++) {
            int tempValue = ((A.length >= i) ? A[A.length - i] : 0) +
                    ((A2.length >= i) ? A2[A2.length - i] : 0);
            tempValue = flag ? tempValue + 1 : tempValue;
            flag = tempValue > 9 ? true : false;
            res.add(0, tempValue % 10);
        }
        if (flag){
            res.add(0,1);
        }
        return res;
    }

    private int[] getA(int k) {
        List<Integer> res = new ArrayList<>();
        int tempValue = k;
        while (tempValue > 0) {
            res.add(tempValue % 10);
            tempValue = tempValue / 10;
        }
        int[] array = new int[res.size()];
        int index = 0;
        //此时 res 是 K 的逆序
        for (int i = res.size() - 1; i >= 0; i--) {
            array[index++] = res.get(i);
        }
        return array;


    }
}
